#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/semaphore.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#define KEY_CNT 1
#define KEY_NAME "gpio-led"



typedef struct key_dev
{
    dev_t devid; //设备号
    struct cdev cdev; //字符设备cdev
    struct lass *class; //字符设备类
    struct device *device;
    int major; //主设备号
    int minor; //次设备号
    struct device_node *nd; //设备节点
    int led_gpio;

}keyDev;

keyDev keyDevice;   //对象实例


/*
 * @description   : 初始化按键IO，open函数打开驱动的时候
 *                  初始化按键所使用的GPIO引脚。
 * @param         : 无
 * @return        : 无
 */
static int keyio_Init(void)
{
    keyDevice.nd = of_find_node_by_path("/swkey");
    if(keyDevice.nd == NULL)
    {
        return -EINVAL;
    }
    keyDevice.key1_gpio = of_get_named_gpio(keyDevice.nd ,"key1-gpio", 0);
    keyDevice.key2_gpio = of_get_named_gpio(keyDevice.nd ,"key2-gpio", 0);

    if((keyDevice.key1_gpio<0) || (keyDevice.key2_gpio <0))
    {
        printk("cant get Key from device Tree\r\n");
        return -EINVAL;
    }
    printk("key1_gpio=%d, key2_gpio=%d\r\n",keyDevice.key1_gpio,keyDevice.key2_gpio);

    gpio_request(keyDevice.key1_gpio,"key1");
    gpio_request(keyDevice.key2_gpio,"key2");
    gpio_direction_input(keyDevice.key1_gpio);
    gpio_direction_input(keyDevice.key2_gpio);
    return 0;
}


/*
 * @description      : 打开设备
 * @param - inode    : 传递给驱动的inode
 * @param - filp     : 设备文件，file结构体有个叫做private_data的成员变量
 *                     一般在open的时候将private_data指向设备结构体。
 * @return           : 0 成功;其他 失败
 */
static int key_open(struct inode *inode, struct file *filp)
{
    int ret = 0;
    filp->private_data = &keyDevice;    /* 设置私有数据 */

    ret = keyio_Init();              /* 初始化按键IO */
    if (ret < 0)
    {
        return ret;
    }

    return 0;
}

/*
 * @description     : 从设备读取数据 
 * @param - filp    : 要打开的设备文件(文件描述符)
 * @param - buf     : 返回给用户空间的数据缓冲区
 * @param - cnt     : 要读取的数据长度
 * @param - offt    : 相对于文件首地址的偏移
 * @return          : 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t key_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
    int ret = 0;
    int value;
    struct  key_dev *dev = filp->private_data;

    if (gpio_get_value(dev->key1_gpio) == 1)         /* key1按下 */
    {
        printk("get key1: high\r\n");
        while(gpio_get_value(dev->key1_gpio));       /* 等待按键释放 */
        atomic_set(&dev->keyvalue, KEY1VALUE);
    }
    else if (gpio_get_value(dev->key2_gpio) == 0)    /* key2按下 */
    {
        printk("get key2: low\r\n");
        while(!gpio_get_value(dev->key2_gpio));      /* 等待按键释放 */
        atomic_set(&dev->keyvalue, KEY2VALUE);
    }
    else
    {
        atomic_set(&dev->keyvalue, INVAKEY);        /* 无效的按键值 */
    }

    value = atomic_read(&dev->keyvalue);
    ret = copy_to_user(buf, &value, sizeof(value));
    return ret;
}

/*
 * @description     : 向设备写数据 
 * @param - filp    : 设备文件，表示打开的文件描述符
 * @param - buf     : 要写给设备写入的数据
 * @param - cnt     : 要写入的数据长度
 * @param - offt    : 相对于文件首地址的偏移
 * @return          : 写入的字节数，如果为负值，表示写入失败
 */
static ssize_t key_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
    return 0;
}

/*
 * @description     : 关闭/释放设备
 * @param - filp    : 要关闭的设备文件(文件描述符)
 * @return          : 0 成功;其他 失败
 */
static int key_release(struct inode *inode, struct file *filp)
{
    return 0;
}


/* 设备操作函数 */
static struct file_operations key_fops = {
    .owner   = THIS_MODULE,
    .open    = key_open,
    .read    = key_read,
    .write   = key_write,
    .release = key_release,
};



static int __init keyDev_init(void)
{
    //原子变量初始化
    atomic_set(&keyDevice.keyvalue,INVAKEY);

    /* 注册字符设备驱动*/
    //如果定义了设备号
    if(keyDevice.major)
    {
        keyDevice.devid = MKDEV(keyDevice.major,0);
        register_chrdev_region(keyDevice.devid,KEY_CNT,KEY_NAME);
    }
    else    //没有定义设备号 向系统申请设备号
    {
        alloc_chrdev_region(&keyDevice.devid,0,KEY_CNT,KEY_NAME);
        keyDevice.major = MAJOR(keyDevice.devid);
        keyDevice.minor = MINOR(keyDevice.devid);
    }
    printk("keyDevice id Major = %d\r\n Minor =%d\r\n",keyDevice.major,keyDevice.minor);

    //2.初始化cdev
    keyDevice.cdev.owner = THIS_MODULE;     
    cdev_init(&keyDevice.cdev,&key_fops); //绑定对象数据与对象方法

     /* 3、添加一个cdev */
    cdev_add(&keyDevice.cdev, keyDevice.devid, KEY_CNT);

    /* 4、创建类 */
    keyDevice.class = class_create(THIS_MODULE, KEY_NAME);
    if (IS_ERR(keyDevice.class))
    {
        return PTR_ERR(keyDevice.class);
    }

    /* 5、创建设备 */
    keyDevice.device = device_create(keyDevice.class, NULL, keyDevice.devid, NULL, KEY_NAME);
    if (IS_ERR(keyDevice.device))
    {
        return PTR_ERR(keyDevice.device);
    }

    printk("keyDevice init done!\n");
    return 0;
}




static int __exit  keyDev_exit(void)
{
     /* 注销字符设备驱动 */
    cdev_del(&keyDevice.cdev);/*  删除cdev */
    unregister_chrdev_region(keyDevice.devid, KEY_CNT); /* 注销设备号 */

    device_destroy(keyDevice.class, keyDevice.devid);
    class_destroy(keyDevice.class);

}

module_init(keyDev_init);
module_exit(keyDev_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("zzlyang");